home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / mus / midi / XGToolset7_src.lha / xgtoolset_src / xgreset / XGReset1.7.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-22  |  12.9 KB  |  514 lines
  1. /*
  2.     RSXG-Reset 1.7
  3.  
  4.     A Bars and Pipes tool for reseting the DB50-XG-board from  YAMAHA.  
  5.     Use it together with the other XG ... .ptool ' s -
  6.  
  7.     © 2000 Alfred Faust
  8.  
  9.     The Tool-code based farly on the code for the "pc3.ptool" from  Richard
  10.     Hagen. That's a very good tool,  many thanks to him.
  11.  
  12.     Richard has written his tool with DICE. We altered the code to  compile
  13.     with  the  free  GNU-C-compiler  of  the  ADE.  Especially the part was
  14.     transcripted,   that  place  the  imagedate  in  chip-RAM,   because  the
  15.     GNU-C-compiler  hasn't as yet a keyword like DICE or other compiler for
  16.     this.
  17.  
  18.     This code is released  into  the  Public  Domain,   and  may  be  freely
  19.     distributed in its original form.
  20.  
  21.     It is supplied ``as is'',  and comes with no warranty. This program code
  22.     was  released  because it might be useful as a starting point for other
  23.     programmers. However,  if any damage arises from its use,   the  original
  24.     author and we will not be held liable.
  25.  
  26.     You are free to use and modify  this  code  to  your  heart's  content,
  27.     provided you acknowledge me as the original author in any code that you
  28.     might distribute which is based largely on this code.
  29.  
  30.     I acknowledge that the design of this tool is  influenced  strongly  by
  31.     the  example code supplied with the Rules for Tools package. However,  I
  32.     have made substantial contributions of my own.
  33.  
  34.     Matthias & Alfred Faust
  35.     j.k.dax@t-online.de
  36.  
  37.     History:
  38.         1.0 (2.12.1998)
  39.         Initial Release.
  40.  
  41.         1.1 (16.6.1999)
  42.         removed a little bug
  43.  
  44.         1.7 (22.9.2000)
  45.         altered the timeshift for the control-sound,
  46.         versionnumber jumpend to 1.7 because all tools havae to have
  47.         the same one
  48.  
  49.  
  50.     
  51. */
  52.  
  53. #include "bars.h"
  54. #include "myheader.h"  // from R.Hagen
  55. #include <libraries/dos.h>
  56. #include <proto/exec.h>
  57. #include <proto/intuition.h>
  58. #include <proto/graphics.h>
  59. #include <exec/memory.h>
  60. #include <exec/execbase.h>
  61. #include <exec/types.h>
  62. #include <string.h>
  63. #include <intuition/intuition.h>
  64.  
  65. char version[]="\0$VER:RSXGEdit V.1.7 (22.09.2000) © Alfred Faust";
  66.  
  67. #define RSXG_NAME "XGReset"
  68.  
  69. #define RSXG_ID          0x52535847
  70. #define RSXG_TYPE        (TOOL_NORMAL | TOOL_NOTPAD)
  71.  
  72.  
  73.  
  74. /* the litte Icon in the pipeline */
  75.  
  76. UWORD *RSXG=NULL;
  77.  
  78. static UWORD RSXGdata[] =
  79. {
  80.         /* Plane 0 */
  81.                 0x7FFF,0xFE00,
  82.                 0x7FFF,0xFE00,
  83.                 0x6000,0x0600,
  84.                 0x79FB,0x9E00,
  85.                 0x7E34,0x7E00,
  86.                 0x7BC3,0xDE00,
  87.                 0x7BF3,0xDE00,
  88.                 0x7A7C,0x5E00,
  89.                 0x79EF,0x9E00,
  90.                 0x6600,0x6600,
  91.                 0x7FFF,0xFE00,
  92.                 0x7FFF,0xFE00,
  93.         /* Plane 1 */
  94.                 0x0000,0x0200,
  95.                 0x0000,0x0600,
  96.                 0x1800,0x1E00,
  97.                 0x07FF,0xE600,
  98.                 0x99FF,0x9F00,
  99.                 0x9A3C,0x5F00,
  100.                 0x9A4F,0xDF00,
  101.                 0x9B83,0xDF00,
  102.                 0x1E6E,0x7E00,
  103.                 0x1800,0x1E00,
  104.                 0x1FFF,0xFE00,
  105.                 0x3FFF,0xFE00,
  106.         /* Plane 2 */
  107.                 0x0000,0x0000,
  108.                 0x0000,0x0000,
  109.                 0x1800,0x1800,
  110.                 0x1FFF,0xF800,
  111.                 0x1FFF,0xF800,
  112.                 0x1BFF,0xD800,
  113.                 0x1BFF,0xD800,
  114.                 0x1BFF,0xD800,
  115.                 0x1FFF,0xF800,
  116.                 0x1E00,0x7800,
  117.                 0x0000,0x0000,
  118.                 0x0000,0x0000
  119. };
  120.  
  121. static struct Image RSXG_image = {
  122.   0, 0,
  123.   24 ,  12 ,  3 ,
  124.   NULL,
  125.   0x1f, 0x00,
  126.   NULL
  127. };
  128.  
  129.  
  130. //Definitions of the gadgets
  131.  
  132. #define WRITE_GADGET 1
  133. #define SEND_GADGET  2
  134.  
  135. //all the gadgets
  136.  
  137.  
  138. /* Write to track gadget. */
  139.  
  140. struct IntuiText RSXGIText1 = {
  141.   4, 0, JAM1, 4, 2, NULL, "Write", NULL
  142.   };
  143.  
  144. struct Gadget RSXGGadget1 = {
  145.   NULL, 60, 18, 45, 11, GFLG_GADGHBOX|GFLG_GADGHIMAGE, RELVERIFY|GADGIMMEDIATE, BOOLGADGET,
  146.   NULL, NULL, &RSXGIText1, NULL, NULL, WRITE_GADGET, NULL
  147.   };
  148.  
  149. /* Test gadget. */
  150.  
  151. struct IntuiText RSXGIText2 = {
  152.   4, 0, JAM1, 4, 2, NULL, "Send", NULL
  153.   };
  154.  
  155. struct Gadget RSXGGadget2 = {
  156.   &RSXGGadget1, 11, 18, 40, 11, GFLG_GADGHBOX|GFLG_GADGHIMAGE, RELVERIFY|GADGIMMEDIATE, BOOLGADGET,
  157.   NULL, NULL, &RSXGIText2, NULL, NULL, SEND_GADGET, NULL
  158.   };                                        
  159.  
  160. //the mainwindowstructure
  161.  
  162. struct NewWindow RSXGNewWindowStructure1 = {
  163.   5, 15,
  164.   120,  35,
  165.   0, 6,
  166.   GADGETDOWN|GADGETUP|CLOSEWINDOW,
  167.   WINDOWDRAG|WINDOWDEPTH|WINDOWCLOSE|ACTIVATE|NOCAREREFRESH,
  168.   &RSXGGadget2,
  169.   NULL,
  170.   "XG Reset",
  171.   NULL,
  172.   NULL,
  173.   5, 5,
  174.   -1, -1,
  175.   CUSTOMSCREEN
  176. };
  177.  
  178. extern struct ExecBase * SysBase;
  179.  
  180. struct RSXGTool {
  181.   struct Tool tool;
  182.  
  183.   char *resetsysex;
  184.   char *xgonsysex;
  185. };
  186.  
  187. static struct ToolMaster master;
  188.  
  189. extern struct Functions *functions;
  190.  
  191. //initial values
  192. static void RSXG_tool_init(struct RSXGTool *tool)
  193. {
  194.   tool->tool.touched = TOUCH_INIT;
  195.  
  196.   tool->resetsysex = "F07E7F0901F7";
  197.   tool->xgonsysex  = "F043104C00007E00F7";
  198. }
  199.  
  200.  
  201. static struct Event * __saveds processeventcode(struct Event *event)
  202. {
  203.   event->tool = event->tool->next;
  204.   return(event);
  205. }
  206.  
  207. static BOOL lock_clip(struct Clip *clip)
  208. {
  209.   Forbid();
  210.   if (clip->locked == 0)
  211.     {
  212.       clip->locked = 1;
  213.       Permit();
  214.       return TRUE;
  215.     }
  216.   else
  217.     {
  218.       Permit();
  219.       return FALSE;
  220.     }
  221. }
  222.  
  223. static void unlock_clip(struct Clip *clip)
  224. {
  225.   clip->locked = 0;
  226. }
  227.  
  228. //writes sysex into track
  229.  
  230. static void __saveds insertsysex(char *buff, short size, struct RSXGTool *tool,  const LONG time)
  231. {
  232.     struct StringEvent *event;
  233.     struct String *string;
  234.  
  235.     event = (struct StringEvent *) (*functions->allocevent)();
  236.      if (event)
  237.       {
  238.         string = (struct String *) (*functions->myalloc)(size + 3, MEMF_CLEAR);
  239.         if (string)
  240.         {
  241.             event->next = NULL;
  242.             event->string = string;
  243.             memcpy(string->string,  buff,  size);
  244.             string->length = size + 2;
  245.             event->type = EVENT_SYSX;
  246.             event->status = MIDI_SYSX;
  247.             event->time = time;
  248.             event->tool = tool->tool.next;
  249.             if (lock_clip(&(tool->tool.track->clip)))
  250.               {
  251.                 event->next = (struct StringEvent *)tool->tool.track->clip.events.first;
  252.                 tool->tool.track->clip.events.first = (struct Event *)(*functions->sorteventlist)(event);
  253.                 unlock_clip(&(tool->tool.track->clip));
  254.               }
  255.             else
  256.               {
  257.                 (*functions->freelist)(event);
  258.               }
  259.  
  260.         }
  261.       }
  262.  
  263. }
  264.  
  265. // the routine for sending SysEx-data thru the pipeline
  266.  
  267. static void __saveds sendsysex(char *buff,  short size,  struct RSXGTool *tool,  const LONG time)
  268. {
  269.     struct StringEvent *event;
  270.     struct String *string;
  271.  
  272.     event = (struct StringEvent *) (*functions->allocevent)();
  273.      if (event)
  274.       {
  275.         string = (struct String *) (*functions->myalloc)(size + 3, MEMF_CLEAR);
  276.         if (string)
  277.         {
  278.             event->string = string;
  279.             memcpy(string->string,  buff,  size);
  280.             string->length = size + 2;
  281.             event->type = EVENT_SYSX;
  282.             event->status = MIDI_SYSX;
  283.             event->time = time;
  284.             event->tool = tool->tool.next;
  285.             WaitTOF();
  286.             (*functions->qevent)(event);
  287.             (*functions->myfree)(string);
  288.         }
  289.       }
  290.  
  291. }
  292.  
  293. static void __saveds trans_hx(struct RSXGTool *tool,  const LONG time,  char *sysx, int sw)
  294. {
  295.   LONG size;
  296.   int a,  b,  x,  y ;
  297.   UBYTE abuf[32];
  298.   char chr[4];
  299.   char *zbuf = NULL;
  300.   struct Event *sysx_event;
  301.  
  302.     //translate sysexbuffer into hex
  303.  
  304.   size = strlen(sysx);
  305.   zbuf = (char *)AllocVec(size+2,  MEMF_ANY|MEMF_CLEAR);
  306.   if(zbuf)
  307.      {
  308.        CopyMem(sysx,  zbuf,  size);
  309.        b=0;
  310.        for(a=0;a < size;a=a+2)
  311.            {
  312.              chr[0] = zbuf[a];
  313.              chr[1] = zbuf[a+1];
  314.  
  315.              x=(isdigit((int)chr[0]))? (chr[0]&0xF) : ((chr[0]&0xDF)-55); //this is the
  316.              y=(isdigit((int)chr[1]))? (chr[1]&0xF) : ((chr[1]&0xDF)-55); //the translate-core
  317.  
  318.              abuf[b++] = ((x<<4)|y);   //writing with bitmanipulation
  319.             }
  320.       //send hexdata
  321.  
  322.        FreeVec(zbuf);
  323.        if (sw == 0) sendsysex(abuf,  b,  tool,  time);
  324.        if (sw == 1) insertsysex(abuf,  b,  tool,  time);
  325.  
  326.      }
  327.  
  328. }
  329.  
  330. //to hear the changes
  331.  
  332. static void send_note(struct RSXGTool *tool,  const long time,  const UBYTE note)
  333. {
  334.   struct NoteEvent *on_event = (struct NoteEvent *)(*functions->allocevent)();
  335.   if (on_event)
  336.     {
  337.       struct NoteEvent *off_event = (struct NoteEvent *)(*functions->allocevent)();
  338.       if (off_event)
  339.         {
  340.           on_event->next  =
  341.           off_event->next = NULL;
  342.  
  343.           on_event->type  =
  344.           off_event->type = EVENT_VOICE;
  345.  
  346.           on_event->status  = MIDI_NOTEON;
  347.           off_event->status = MIDI_NOTEOFF;
  348.  
  349.           on_event->value  =
  350.           off_event->value = note;
  351.  
  352.           on_event->velocity = 80;
  353.  
  354.           on_event->time  = time;
  355.           off_event->time = time + 200;
  356.  
  357.           on_event->tool  =
  358.           off_event->tool = tool->tool.next;
  359.  
  360.           (*functions->qevent)(on_event);
  361.           (*functions->qevent)(off_event);
  362.         }
  363.       else
  364.         {
  365.           (*functions->freeevent)(on_event);
  366.         }
  367.     }
  368. }
  369.  
  370.  
  371. //the center off all
  372.  
  373. static void __saveds edittoolcode(struct RSXGTool *tool)
  374. {
  375.   struct IntuiMessage *message;
  376.   struct Window *window;
  377.   LONG class,  code,  time;
  378.   struct Gadget *gadget;
  379.   struct NewWindow *newwindow;
  380.   int i;
  381.  
  382.  
  383.   RSXGNewWindowStructure1.Screen = functions->screen;
  384.  
  385.   if (tool->tool.touched & TOUCH_EDIT)
  386.     {
  387.       RSXGNewWindowStructure1.LeftEdge = tool->tool.left;
  388.       RSXGNewWindowStructure1.TopEdge = tool->tool.top;
  389.       RSXGNewWindowStructure1.Width = tool->tool.width;
  390.       RSXGNewWindowStructure1.Height = tool->tool.height;
  391.     }
  392.   
  393.   if (!tool->tool.touched)
  394.     {
  395.       RSXG_tool_init(tool);
  396.     }
  397.  
  398.   newwindow = (struct NewWindow *) (*functions->DupeNewWindow)(&RSXGNewWindowStructure1);
  399.   if (!newwindow)
  400.     {
  401.       return;
  402.     }
  403.   newwindow->Title = 0;
  404.   newwindow->Flags |= BORDERLESS;
  405.   newwindow->Flags &= ~0xF;
  406.   newwindow->BlockPen = 0;
  407.   newwindow->DetailPen = 0;
  408.  
  409.   window = (struct Window *) (*functions->FlashyOpenWindow)(newwindow);
  410.   if (!window)
  411.     {
  412.       return;
  413.     }
  414.   tool->tool.window = window;
  415.   (*functions->EmbossWindowOn)(window, WINDOWCLOSE|WINDOWDEPTH|WINDOWDRAG,  RSXG_NAME, (short)-1, (short)-1, 0, 0);
  416.  
  417.  
  418.   (*functions->EmbossOn)(window,  WRITE_GADGET,  1);
  419.   (*functions->EmbossOn)(window,  SEND_GADGET,  1);
  420.   //send_note(tool,  functions->timenow,  60);
  421.  
  422.   for (;;)
  423.     {
  424.  
  425.       message = (struct IntuiMessage *) (*functions->GetIntuiMessage)(window);
  426.       class = message->Class;
  427.       code = message->Code;
  428.       gadget = (struct Gadget *) message->IAddress;
  429.       class = (*functions->SystemGadgets)(window, class, gadget, code);
  430.  
  431.       ReplyMsg((struct Message *)message);
  432.  
  433.  
  434.       if (class == CLOSEWINDOW)
  435.         {
  436.           break;
  437.         }
  438.       else if (class == GADGETDOWN)
  439.         {
  440.           const short id = gadget->GadgetID;
  441.           switch (id)
  442.             {
  443.             case WRITE_GADGET:
  444.               if ((*functions->areyousure)("write Reset-data to track ?"))
  445.                   {
  446.                   if (!functions->running)
  447.                       {
  448.                        if (tool->resetsysex != NULL) trans_hx(tool,  1,  tool->resetsysex, 1);
  449.                        if (tool->xgonsysex != NULL) trans_hx(tool,  384,  tool->xgonsysex, 1);
  450.                       }
  451.                   }
  452.                 send_note(tool,  time+200,  60);
  453.               break;
  454.             case SEND_GADGET:
  455.               {
  456.                 trans_hx(tool, functions->timenow, tool->resetsysex, 0);
  457.                 trans_hx(tool, functions->timenow+200, tool->xgonsysex, 0);
  458.                 send_note(tool,  functions->timenow+300,  60);
  459.               }
  460.             default:
  461.             break;
  462.             }
  463.           }
  464.       else if (class == GADGETUP)
  465.         {
  466.           /* Nothing. */
  467.         }
  468.     }
  469.   tool->tool.window = 0;
  470.   tool->tool.left = window->LeftEdge;
  471.   tool->tool.top = window->TopEdge;
  472.   tool->tool.width = window->Width;
  473.   tool->tool.height = window->Height;
  474.   tool->tool.touched = TOUCH_INIT | TOUCH_EDIT;
  475.  
  476.  
  477.   (*functions->EmbossOff)(window,  WRITE_GADGET);
  478.   (*functions->EmbossOff)(window,  SEND_GADGET);
  479.   
  480.   (*functions->EmbossWindowOff)(window);
  481.   (*functions->FlashyCloseWindow)(window);
  482.   (*functions->DeleteNewWindow)(newwindow);
  483. }
  484.  
  485. //to leave the tool correct
  486.  
  487. void __saveds removetool()
  488. {
  489. FreeVec(RSXG);
  490. }
  491.  
  492. //start of the tool
  493.  
  494. struct ToolMaster * inittoolmaster()
  495. {
  496.   int i = 0,  bank = 0;
  497.  
  498.   if (!(RSXG=(UWORD *)AllocVec(sizeof (RSXGdata), MEMF_CHIP|MEMF_CLEAR))) return(NULL);
  499.   CopyMem(&RSXGdata, RSXG,  sizeof (RSXGdata));
  500.  
  501.  
  502.   RSXG_image.ImageData = RSXG;
  503.   memset((char *)&master, 0, sizeof(struct ToolMaster));
  504.   master.toolid = RSXG_ID;
  505.   master.image = &RSXG_image;
  506.   strcpy(master.name,  RSXG_NAME);
  507.   master.edittool = edittoolcode;
  508.   master.processevent = processeventcode;
  509.   master.tooltype = RSXG_TYPE;
  510.   master.toolsize = sizeof(struct RSXGTool);
  511.   master.removetool = removetool;
  512.   return(&master);
  513. }
  514.